xr_api_defs.h

Go to the documentation of this file.

 
#ifndef XR_API_DEFS_H_
#define XR_API_DEFS_H_
 
#include "xr_math.h"
 
// = Standard Library =============================
#include <stdint.h>
#include <wchar.h>
 
#include <string>
 
// XR_PTR_SIZE (in bytes)
#if (defined(__LP64__) || defined(_WIN64) ||                            \
     (defined(__x86_64__) && !defined(__ILP32__)) || defined(_M_X64) || \
     defined(__ia64) || defined(_M_IA64) || defined(__aarch64__) ||     \
     defined(__powerpc64__))
#define XR_PTR_SIZE 8
#else
#define XR_PTR_SIZE 4
#endif
 
#if !defined(XR_DEFINE_HANDLE)
#if (XR_PTR_SIZE == 8)
#define XR_DEFINE_HANDLE(object) typedef struct object##_T* object;
#else
#define XR_DEFINE_HANDLE(object) typedef uint64_t object;
#endif
#endif
 
const float kDefaultDisplayWidth_m = 0.3442176f;
const float kDefaultDisplayHeight_m = 0.1936224f;
const float kDefaultDisplayTilt_rad = 0.785398f;  // = 45f * deg2rad
const uint32_t kDefaultHorizontalResolution_px = 3840;
const uint32_t kDefaultVerticalResolution_px = 2160;
 
enum class SonyOzResult {
  SUCCESS = 0,                      
  ERROR_RUNTIME_NOT_FOUND = -1,     
  ERROR_VALIDATION_FAILURE = -2,    
  ERROR_RUNTIME_FAILURE = -3,       
  ERROR_FUNCTION_UNSUPPORTED = -4,  
  ERROR_HANDLE_INVALID = -5,        
  ERROR_SESSION_CREATED = -6,       
  ERROR_SESSION_READY = -7,         
  ERROR_SESSION_STARTING = -8,      
  ERROR_SESSION_RUNNING = -9,       
  ERROR_SESSION_STOPPING = -10,     
  ERROR_SESSION_NOT_CREATE = -11,   
  ERROR_SESSION_NOT_READY = -12,    
  ERROR_SESSION_NOT_RUNNING = -13,  
  ERROR_SESSION_STILL_USED = -14,   
  ERROR_POSE_INVALID = -15,         
  ERROR_SET_DATA_FAILURE = -16,     
  ERROR_GET_DATA_FAILURE = -17,     
  ERROR_FILE_ACCESS_ERROR = -18,    
  ERROR_DEVICE_NOT_FOUND = -19,     
  ERROR_RUNTIME_UNSUPPORTED = -20   
};
 
typedef const char* SonyOzPlatformId;
 
enum class SonyOzSessionState {
  UNKNOWN = 0b00000000,   
  IDLE = 0b00000001,      
  READY = 0b00000010,     
  STARTING = 0b00000100,  
  RUNNING = 0b00001000,   
  STOPPING = 0b00010000,  
};
 
struct SonyOzRect {
  int32_t left;
 
  int32_t top;
 
  int32_t right;
 
  int32_t bottom;
};
 
const uint32_t kDeviceSerialNumberMaxSize = 256;
const uint32_t kDeviceProductIdMaxSize = 256;
struct SonyOzDeviceInfo {
  uint32_t device_index;
 
  char device_serial_number[kDeviceSerialNumberMaxSize] = "";
 
  char product_id[kDeviceProductIdMaxSize] = "";
 
  SonyOzRect target_monitor_rectangle;
 
  SonyOzRect primary_monitor_rectangle;
 
  SonyOzDeviceInfo() {};
  SonyOzDeviceInfo(const SonyOzDeviceInfo& obj)
      : device_index(obj.device_index),
        target_monitor_rectangle(obj.target_monitor_rectangle),
        primary_monitor_rectangle(obj.primary_monitor_rectangle) {
      strcpy_s(device_serial_number, sizeof(device_serial_number), obj.device_serial_number);
      strcpy_s(product_id, sizeof(product_id), obj.product_id);
  }
};
 
enum class SonyOzMultiDisplayMode {
    Single = 0,
    Virtical = 1,
    Horizontal = 2,
    Grid = 3,
    Clone = 4,
    Multiple = 5
};
 
struct SonyOzMultiDisplayDeviceInfo {
    struct SonyOzDeviceInfo device_info;
    enum SonyOzMultiDisplayMode multi_display_mode = SonyOzMultiDisplayMode::Single;
};
 
struct SonyOzFovf {
  float angle_left;   
  float angle_right;  
  float angle_up;     
  float angle_down;   
 
  SonyOzFovf()
      : angle_left(0.f), angle_right(0.f), angle_up(0.f), angle_down(0.f) {}
 
  SonyOzFovf(float in_angle)
      : angle_left(in_angle),
        angle_right(in_angle),
        angle_up(in_angle),
        angle_down(in_angle) {}
 
  SonyOzFovf(float in_angle_left, float in_angle_right, float in_angle_up,
             float in_angle_down)
      : angle_left(in_angle_left),
        angle_right(in_angle_right),
        angle_up(in_angle_up),
        angle_down(in_angle_down) {}
};
 
struct SonyOzFrustumPlanesf {
  float viewLeft;
  float viewRight;
  float viewBottom;
  float viewTop;
  float nearZ;
  float farZ;
 
  SonyOzFrustumPlanesf(float horizontal_fov, float vertical_fov,
                       float near_clip, float far_clip)
      : viewLeft(near_clip * tanf(horizontal_fov * 0.5f)),
        viewRight(-near_clip * tanf(horizontal_fov * 0.5f)),
        viewBottom(-near_clip * tanf(vertical_fov * 0.5f)),
        viewTop(near_clip * tanf(vertical_fov * 0.5f)),
        nearZ(near_clip),
        farZ(far_clip) {}
 
  SonyOzFrustumPlanesf() : SonyOzFrustumPlanesf(1.47f, 0.70f, 0.15f, 10.f) {}
 
  SonyOzFrustumPlanesf(float in_view_left, float in_view_right,
                       float in_view_bottom, float in_view_top, float in_near_z,
                       float in_far_z)
      : viewLeft(in_view_left),
        viewRight(in_view_right),
        viewBottom(in_view_bottom),
        viewTop(in_view_top),
        nearZ(in_near_z),
        farZ(in_far_z) {}
 
  SonyOzFovf ToFov() {
    return SonyOzFovf(atan2f(fabsf(viewLeft), fabsf(nearZ)),
                      atan2f(fabsf(viewRight), fabsf(nearZ)),
                      atan2f(fabsf(viewTop), fabsf(nearZ)),
                      atan2f(fabsf(viewBottom), fabsf(nearZ)));
  }
};
 
struct SonyOzPosef {
  SonyOzQuaternionf orientation;
 
  SonyOzVector3f position;
 
  SonyOzPosef() {}
 
  SonyOzPosef(SonyOzQuaternionf in_orientation, SonyOzVector3f in_position)
      : orientation(in_orientation), position(in_position) {}
};
 
struct SonyOzHeadPosef {
  SonyOzPosef pose;
 
  SonyOzPosef left_eye_pose;
 
  SonyOzPosef right_eye_pose;
};
 
struct SonyOzDisplayResolution {
  uint32_t width;
 
  uint32_t height;
 
  uint32_t area;
 
  SonyOzDisplayResolution() : width(0), height(0), area(width * height) {}
 
  SonyOzDisplayResolution(uint32_t in_width, uint32_t in_height)
      : width(in_width), height(in_height), area(width * height) {}
};
 
struct SonyOzDisplaySize {
  float width_m;
 
  float height_m;
 
  SonyOzDisplaySize()
      : width_m(kDefaultDisplayWidth_m), height_m(kDefaultDisplayHeight_m) {}
 
  SonyOzDisplaySize(float in_width_m, float in_height_m)
      : width_m(in_width_m), height_m(in_height_m) {}
};
 
struct SonyOzProjectionMatrix {
  SonyOzMatrix4x4f projection;
 
  SonyOzMatrix4x4f left_projection;
 
  SonyOzMatrix4x4f right_projection;
};
 
struct SonyOzDisplaySpec {
  SonyOzDisplaySize display_size;
 
  SonyOzDisplayResolution display_resolution;
 
  float display_tilt_rad;
 
  SonyOzDisplaySpec()
      : display_size(kDefaultDisplayWidth_m, kDefaultDisplayHeight_m),
        display_resolution(kDefaultHorizontalResolution_px,
                           kDefaultVerticalResolution_px),
        display_tilt_rad(kDefaultDisplayTilt_rad) {}
 
  SonyOzDisplaySpec(SonyOzDisplaySize in_display_size,
                    SonyOzDisplayResolution in_display_resolution,
                    float in_display_tilt_rad)
      : display_size(in_display_size),
        display_resolution(in_display_resolution),
        display_tilt_rad(in_display_tilt_rad) {}
};
 
enum class SonyOzXrSystemErrorResult : uint8_t { Success, Warning, Error };
 
constexpr uint16_t kXrSystemErrorMsgSize = 512;
struct SonyOzXrSystemError {
  SonyOzXrSystemErrorResult result = SonyOzXrSystemErrorResult::Success;
  int32_t code = 0;
  char msg[kXrSystemErrorMsgSize] = "";
 
  SonyOzXrSystemError() {}
  SonyOzXrSystemError(SonyOzXrSystemErrorResult in_result, int32_t in_code,
                      const char* in_msg)
      : result(in_result), code(in_code) {
      strcpy_s(msg, sizeof(msg), in_msg);
  };
};
 
enum class SonyOzPoseId : int32_t {
  HEAD = 0,       
  LEFT_EYE = 1,   
  RIGHT_EYE = 2,  
};
 
struct SonyOzProjection {
    float half_angles_left;
    float half_angles_right;
    float half_angles_top;
    float half_angles_bottom;
};
 
struct ID3D11Device;
struct ID3D11Texture2D;
struct ID3D12CommandQueue;
struct ID3D12Resource;
struct ID3D11Resource;
struct ID3D11RenderTargetView;
struct ID3D11ShaderResourceView;
 
#if defined(_WIN32)
  enum DXGI_FORMAT;
#else
  typedef enum DXGI_FORMAT {
    DXGI_FORMAT_UNKNOWN = 0,
  } DXGI_FORMAT;
#endif
 
#endif  // XR_API_DEFS_H_